home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1997 May / EnigmA AMIGA RUN 18 (1997)(G.R. Edizioni)(IT)[!][issue 1997-05][EAR-CD II].iso / earcd / misc / emu / arosdev.lha / AROS / workbench / libs / icon / diskobjio.c < prev    next >
C/C++ Source or Header  |  1997-02-07  |  11KB  |  538 lines
  1. /*
  2.     (C) 1995-96 AROS - The Amiga Replacement OS
  3.     $Id: diskobjio.c,v 1.1 1997/02/07 14:11:36 digulla Exp $
  4.  
  5.     Desc: Read an icon from an .info file
  6.     Lang: english
  7. */
  8.  
  9. #include <stdio.h>
  10. #include <stddef.h>
  11.  
  12. #include <exec/memory.h>
  13. #include <aros/structdesc.h>
  14. #include <aros/asmcall.h>
  15. #include <aros/debug.h>
  16. #include <workbench/workbench.h>
  17. /* #include <intuition/intuitionbase.h>
  18. #include <intuition/intuition.h>
  19. #include <graphics/gfxbase.h>
  20. #include <graphics/rastport.h> */
  21.  
  22. #include <proto/alib.h>
  23. #include <proto/exec.h>
  24. #include <proto/dos.h>
  25. #include <proto/aros.h>
  26. #include <proto/intuition.h>
  27.  
  28. static AROS_UFH3(ULONG, ProcessDrawerData,
  29.     AROS_UFHA(struct Hook *,   hook, A0),
  30.     AROS_UFHA(BPTR,            file, A2),
  31.     AROS_UFHA(struct SDData *, data, A1)
  32. );
  33. static AROS_UFH3(ULONG, ProcessGadgetRender,
  34.     AROS_UFHA(struct Hook *,   hook, A0),
  35.     AROS_UFHA(BPTR,            file, A2),
  36.     AROS_UFHA(struct SDData *, data, A1)
  37. );
  38. static AROS_UFH3(ULONG, ProcessSelectRender,
  39.     AROS_UFHA(struct Hook *,   hook, A0),
  40.     AROS_UFHA(BPTR,            file, A2),
  41.     AROS_UFHA(struct SDData *, data, A1)
  42. );
  43. static AROS_UFH3(ULONG, ProcessDefaultTool,
  44.     AROS_UFHA(struct Hook *,   hook, A0),
  45.     AROS_UFHA(BPTR,            file, A2),
  46.     AROS_UFHA(struct SDData *, data, A1)
  47. );
  48. static AROS_UFH3(ULONG, ProcessToolTypes,
  49.     AROS_UFHA(struct Hook *,   hook, A0),
  50.     AROS_UFHA(BPTR,            file, A2),
  51.     AROS_UFHA(struct SDData *, data, A1)
  52. );
  53. static AROS_UFH3(ULONG, ProcessFlagPtr,
  54.     AROS_UFHA(struct Hook *,   hook, A0),
  55.     AROS_UFHA(BPTR,            file, A2),
  56.     AROS_UFHA(struct SDData *, data, A1)
  57. );
  58.  
  59. static const struct Hook ProcessDrawerDataHook =
  60. {
  61.     { NULL, NULL}, ProcessDrawerData, NULL, NULL
  62. },
  63. ProcessGadgetRenderHook =
  64. {
  65.     { NULL, NULL}, ProcessGadgetRender, NULL, NULL
  66. },
  67. ProcessSelectRenderHook =
  68. {
  69.     { NULL, NULL}, ProcessSelectRender, NULL, NULL
  70. },
  71. ProcessFlagPtrHook =
  72. {
  73.     { NULL, NULL}, ProcessFlagPtr, NULL, NULL
  74. },
  75. ProcessDefaultToolHook =
  76. {
  77.     { NULL, NULL}, ProcessDefaultTool, NULL, NULL
  78. },
  79. ProcessToolTypesHook =
  80. {
  81.     { NULL, NULL}, ProcessToolTypes, NULL, NULL
  82. };
  83.  
  84. #undef O
  85. #define O(x)    (offsetof (struct Gadget,x))
  86. static const IPTR GadgetDesc[] =
  87. {
  88.     sizeof (struct Gadget),
  89.     SDM_IGNORE(4), /* NextGadget */
  90.     SDM_WORD(O(LeftEdge)),
  91.     SDM_WORD(O(TopEdge)),
  92.     SDM_WORD(O(Width)),
  93.     SDM_WORD(O(Height)),
  94.     SDM_UWORD(O(Flags)),
  95.     SDM_UWORD(O(Activation)),
  96.     SDM_UWORD(O(GadgetType)),
  97.     SDM_SPECIAL(O(GadgetRender),&ProcessFlagPtrHook),
  98.     SDM_SPECIAL(O(SelectRender),&ProcessFlagPtrHook),
  99.     SDM_SPECIAL(O(GadgetText),&ProcessFlagPtrHook),
  100.     SDM_LONG(O(MutualExclude)),
  101.     SDM_SPECIAL(O(SpecialInfo),&ProcessFlagPtrHook),
  102.     SDM_UWORD(O(GadgetID)),
  103.     SDM_ULONG(O(UserData)),
  104.     SDM_END
  105. };
  106.  
  107. #undef O
  108. #define O(x)    (offsetof (struct DiskObject,x))
  109. static const IPTR DiskObjectDesc[] =
  110. {
  111.     sizeof (struct DiskObject),
  112.     SDM_UWORD(O(do_Magic)),
  113.     SDM_UWORD(O(do_Version)),
  114.     SDM_STRUCT(O(do_Gadget),GadgetDesc),
  115.     SDM_UBYTE(O(do_Type)),
  116.     SDM_IGNORE(1), /* Pad */
  117.     SDM_SPECIAL(O(do_DefaultTool),&ProcessFlagPtrHook),
  118.     SDM_SPECIAL(O(do_ToolTypes),&ProcessFlagPtrHook),
  119.     SDM_LONG(O(do_CurrentX)),
  120.     SDM_LONG(O(do_CurrentY)),
  121.     SDM_SPECIAL(O(do_DrawerData),&ProcessFlagPtrHook),
  122.     SDM_SPECIAL(O(do_ToolWindow),&ProcessFlagPtrHook),
  123.     SDM_LONG(O(do_StackSize)),
  124.     SDM_END
  125. };
  126.  
  127. #undef O
  128. #define O(x)    (offsetof (struct Image,x))
  129. static const IPTR ImageDesc[] =
  130. {
  131.     sizeof (struct Image),
  132.     SDM_WORD(O(LeftEdge)),
  133.     SDM_WORD(O(TopEdge)),
  134.     SDM_WORD(O(Width)),
  135.     SDM_WORD(O(Height)),
  136.     SDM_WORD(O(Depth)),
  137.     SDM_SPECIAL(O(ImageData),&ProcessFlagPtrHook),
  138.     SDM_UBYTE(O(PlanePick)),
  139.     SDM_UBYTE(O(PlaneOnOff)),
  140.     SDM_SPECIAL(O(NextImage),&ProcessFlagPtrHook),
  141.     SDM_END
  142. };
  143.  
  144. const IPTR IconDesc[] =
  145. {
  146.     sizeof (struct DiskObject),
  147.     SDM_STRUCT(0,DiskObjectDesc),
  148.     SDM_SPECIAL(0,&ProcessDrawerDataHook),
  149.     SDM_SPECIAL(0,&ProcessGadgetRenderHook),
  150.     SDM_SPECIAL(0,&ProcessSelectRenderHook),
  151.     SDM_SPECIAL(0,&ProcessDefaultToolHook),
  152.     SDM_SPECIAL(0,&ProcessToolTypesHook),
  153.     SDM_END
  154. };
  155.  
  156. /*    if (!WriteStruct (icon, dobj, IconDesc))
  157.  
  158.         FreeStruct (dobj, DiskObjectDesc); */
  159.  
  160. #define DO(x)       ((struct DiskObject *)x)
  161.  
  162. static AROS_UFH3(ULONG, ProcessDrawerData,
  163.     AROS_UFHA(struct Hook *,   hook, A0),
  164.     AROS_UFHA(BPTR,            file, A2),
  165.     AROS_UFHA(struct SDData *, data, A1)
  166. )
  167. {
  168. /* kprintf ("ProcessDrawerData\n"); */
  169.     if (DO(data->sdd_Dest)->do_Type == WBDRAWER)
  170.     {
  171.     switch (data->sdd_Mode)
  172.     {
  173.     case SDV_SPECIALMODE_READ:
  174.         Flush (file);
  175.  
  176.         return Seek (file, DRAWERDATAFILESIZE, OFFSET_CURRENT) != EOF;
  177.  
  178.     case SDV_SPECIALMODE_WRITE:
  179.         return Write (file
  180.         , DO(data->sdd_Dest)->do_DrawerData
  181.         , DRAWERDATAFILESIZE
  182.         ) != EOF;
  183.  
  184.     case SDV_SPECIALMODE_FREE:
  185.         break;
  186.     }
  187.     }
  188.  
  189.     return TRUE;
  190. } /* ProcessDrawerData */
  191.  
  192. static struct Image * ReadImage (BPTR file)
  193. {
  194.     struct Image * image;
  195.     ULONG       size;
  196.     ULONG       t;
  197.  
  198.     if (!ReadStruct (file, (APTR *)&image, ImageDesc))
  199.     return NULL;
  200.  
  201.     /* Size of imagedata in bytes */
  202.     size = ((image->Width + 15) >> 3) * image->Height * image->Depth;
  203.  
  204. /* kprintf ("ReadImage: %dx%dx%d (%d bytes)\n"
  205.     , image->Width
  206.     , image->Height
  207.     , image->Depth
  208.     , size
  209. ); */
  210.  
  211.     if (size)
  212.     {
  213.     if (!(image->ImageData = AllocMem (size, MEMF_CHIP)) )
  214.     {
  215.         FreeStruct (image, ImageDesc);
  216.         return NULL;
  217.     }
  218.  
  219.     size >>= 1; /* Get size in words */
  220.  
  221.     for (t=0; t<size; t++)
  222.         if (!ReadWord (file, &image->ImageData[t]))
  223.         break;
  224.  
  225.     if (t != size)
  226.     {
  227.         FreeStruct (image, ImageDesc);
  228.         return NULL;
  229.     }
  230.     }
  231.  
  232.     return image;
  233. } /* ReadImage */
  234.  
  235. static int WriteImage (BPTR file, struct Image * image)
  236. {
  237.     ULONG size;
  238.     ULONG t;
  239.  
  240.     if (!WriteStruct (file, image, ImageDesc) )
  241.     return FALSE;
  242.  
  243.     /* Get size in words */
  244.     size = ((image->Width + 15) >> 4) * image->Height * image->Depth;
  245.  
  246.     for (t=0; t<size; t++)
  247.     if (!WriteWord (file, image->ImageData[t]))
  248.         break;
  249.  
  250.     return (t == size);
  251. } /* WriteImage */
  252.  
  253. static void FreeImage (struct Image * image)
  254. {
  255.     ULONG size;
  256.  
  257.     /* Get size in bytes */
  258.     size = ((image->Width + 15) >> 3) * image->Height * image->Depth;
  259.  
  260.     if (size)
  261.     FreeMem (image->ImageData, size);
  262.  
  263.     FreeStruct (image, ImageDesc);
  264. } /* FreeImage */
  265.  
  266. static AROS_UFH3(ULONG, ProcessGadgetRender,
  267.     AROS_UFHA(struct Hook *,   hook, A0),
  268.     AROS_UFHA(BPTR,            file, A2),
  269.     AROS_UFHA(struct SDData *, data, A1)
  270. )
  271. {
  272.     struct Image * image;
  273. /* kprintf ("ProcessGadgetRender\n"); */
  274.  
  275.     switch (data->sdd_Mode)
  276.     {
  277.     case SDV_SPECIALMODE_READ:
  278.     image = ReadImage (file);
  279.  
  280.     if (!image)
  281.         return FALSE;
  282.  
  283.     DO(data->sdd_Dest)->do_Gadget.GadgetRender = image;
  284.  
  285.     break;
  286.  
  287.     case SDV_SPECIALMODE_WRITE:
  288.     image = DO(data->sdd_Dest)->do_Gadget.GadgetRender;
  289.  
  290.     return WriteImage (file, image);
  291.  
  292.     case SDV_SPECIALMODE_FREE:
  293.     image = DO(data->sdd_Dest)->do_Gadget.GadgetRender;
  294.  
  295.     FreeImage (image);
  296.  
  297.     break;
  298.     }
  299.  
  300.     return TRUE;
  301. } /* ProcessGadgetRender */
  302.  
  303. static AROS_UFH3(ULONG, ProcessSelectRender,
  304.     AROS_UFHA(struct Hook *,   hook, A0),
  305.     AROS_UFHA(BPTR,            file, A2),
  306.     AROS_UFHA(struct SDData *, data, A1)
  307. )
  308. {
  309.     struct Image * image;
  310. /* kprintf ("ProcessSelectRender\n"); */
  311.  
  312.     if (DO(data->sdd_Dest)->do_Gadget.Flags & GFLG_GADGHIMAGE)
  313.     {
  314.     switch (data->sdd_Mode)
  315.     {
  316.     case SDV_SPECIALMODE_READ:
  317.         image = ReadImage (file);
  318.  
  319.         if (!image)
  320.         return FALSE;
  321.  
  322.         DO(data->sdd_Dest)->do_Gadget.SelectRender = image;
  323.  
  324.         break;
  325.  
  326.     case SDV_SPECIALMODE_WRITE:
  327.         image = DO(data->sdd_Dest)->do_Gadget.SelectRender;
  328.  
  329.         return WriteImage (file, image);
  330.  
  331.     case SDV_SPECIALMODE_FREE:
  332.         image = DO(data->sdd_Dest)->do_Gadget.SelectRender;
  333.  
  334.         FreeImage (image);
  335.  
  336.         break;
  337.     }
  338.     }
  339.  
  340.     return TRUE;
  341. } /* ProcessSelectRender */
  342.  
  343. static AROS_UFH3(ULONG, ProcessFlagPtr,
  344.     AROS_UFHA(struct Hook *,   hook, A0),
  345.     AROS_UFHA(BPTR,            file, A2),
  346.     AROS_UFHA(struct SDData *, data, A1)
  347. )
  348. {
  349.     LONG ptr;
  350.  
  351.     switch (data->sdd_Mode)
  352.     {
  353.     case SDV_SPECIALMODE_READ:
  354.     if (FRead (file, &ptr, 4, 1) == EOF)
  355.         return FALSE;
  356.  
  357.     *((APTR *)data->sdd_Dest) = (APTR)(ptr != 0L);
  358.  
  359.     break;
  360.  
  361.     case SDV_SPECIALMODE_WRITE:
  362.     if (*((APTR *)data->sdd_Dest))
  363.         ptr = 0xABADCAFEL;
  364.     else
  365.         ptr = 0L;
  366.  
  367.     if (FWrite (file, &ptr, 4, 1) == EOF)
  368.         return FALSE;
  369.  
  370.     break;
  371.  
  372.     case SDV_SPECIALMODE_FREE:
  373.     break;
  374.     }
  375.  
  376.  
  377.     return TRUE;
  378. } /* ProcessFlagPtr */
  379.  
  380. static STRPTR ReadIconString (BPTR file)
  381. {
  382.     ULONG  len;
  383.     STRPTR str;
  384.  
  385.     if (!ReadLong (file, &len))
  386.     return NULL;
  387.  
  388.     str = AllocMem (len, MEMF_ANY);
  389.  
  390.     if (!str)
  391.     return NULL;
  392.  
  393.     if (FRead (file, str, len, 1) == EOF)
  394.     {
  395.     FreeMem (str, len);
  396.     return NULL;
  397.     }
  398.  
  399.     return str;
  400. } /* ReadIconString */
  401.  
  402. static int WriteIconString (BPTR file, STRPTR str)
  403. {
  404.     ULONG len;
  405.  
  406.     len = strlen (str) + 1;
  407.  
  408.     if (!WriteLong (file, len))
  409.     return FALSE;
  410.  
  411.     return FWrite (file, str, len, 1) != EOF;
  412. } /* WriteIconString */
  413.  
  414. static AROS_UFH3(ULONG, ProcessDefaultTool,
  415.     AROS_UFHA(struct Hook *,   hook, A0),
  416.     AROS_UFHA(BPTR,            file, A2),
  417.     AROS_UFHA(struct SDData *, data, A1)
  418. )
  419. {
  420.     STRPTR str;
  421.  
  422.     if (DO(data->sdd_Dest)->do_DefaultTool)
  423.     {
  424.     switch (data->sdd_Mode)
  425.     {
  426.     case SDV_SPECIALMODE_READ:
  427.         str = ReadIconString (file);
  428.  
  429.         if (!str)
  430.         return FALSE;
  431.  
  432.         DO(data->sdd_Dest)->do_DefaultTool = str;
  433.  
  434.         break;
  435.  
  436.     case SDV_SPECIALMODE_WRITE: {
  437.         str = DO(data->sdd_Dest)->do_DefaultTool;
  438.  
  439.         WriteIconString (file, str);
  440.  
  441.         break; }
  442.  
  443.     case SDV_SPECIALMODE_FREE:
  444.         str = DO(data->sdd_Dest)->do_DefaultTool;
  445.  
  446.         FreeMem (str, strlen (str)+1);
  447.  
  448.         break;
  449.     }
  450.     }
  451.  
  452.     return TRUE;
  453. } /* ProcessDefaultTool */
  454.  
  455. static AROS_UFH3(ULONG, ProcessToolTypes,
  456.     AROS_UFHA(struct Hook *,   hook, A0),
  457.     AROS_UFHA(BPTR,            file, A2),
  458.     AROS_UFHA(struct SDData *, data, A1)
  459. )
  460. {
  461.     if (DO(data->sdd_Dest)->do_ToolTypes)
  462.     {
  463.     ULONG     t;
  464.     ULONG     count;
  465.     STRPTR * ttarray;
  466.  
  467.     switch (data->sdd_Mode)
  468.     {
  469.     case SDV_SPECIALMODE_READ:
  470.         /* Read size of ToolTypes array (each entry is 4 bytes and the
  471.            last is 0L */
  472.         if (!ReadLong (file, &count))
  473.         return FALSE;
  474.  
  475.         count = (count >> 2) - 1; /* How many entries */
  476.  
  477.         ttarray = AllocMem ((count+1)*sizeof(STRPTR), MEMF_ANY);
  478.  
  479.         for (t=0; t<count; t++)
  480.         {
  481.         ttarray[t] = ReadIconString (file);
  482.  
  483.         if (!ttarray[t])
  484.         {
  485.             ULONG i;
  486.  
  487.             for (i=0; i<t; i++)
  488.             FreeMem (ttarray[t], strlen (ttarray[t])+1);
  489.  
  490.             FreeMem (ttarray, (count+1)*sizeof(STRPTR));
  491.  
  492.             return FALSE;
  493.         }
  494.         }
  495.  
  496.         ttarray[t] = NULL;
  497.  
  498.         DO(data->sdd_Dest)->do_ToolTypes = (char **)ttarray;
  499.  
  500.         break;
  501.  
  502.     case SDV_SPECIALMODE_WRITE: {
  503.         ULONG size;
  504.  
  505.         ttarray = (STRPTR *)DO(data->sdd_Dest)->do_ToolTypes;
  506.  
  507.         for (count=0; ttarray[count]; count++);
  508.  
  509.         size = (count+1)*4;
  510.  
  511.         if (!WriteLong (file, size))
  512.         return FALSE;
  513.  
  514.         for (t=0; t<count; t++)
  515.         {
  516.         if (!WriteIconString (file, ttarray[t]))
  517.             return FALSE;
  518.         }
  519.  
  520.         break; }
  521.  
  522.     case SDV_SPECIALMODE_FREE:
  523.         ttarray = (STRPTR *)DO(data->sdd_Dest)->do_ToolTypes;
  524.  
  525.         for (t=0; ttarray[t]; t++)
  526.         FreeMem (ttarray[t], strlen (ttarray[t])+1);
  527.  
  528.         FreeMem (ttarray, (t+1)*sizeof(STRPTR));
  529.  
  530.         break;
  531.     }
  532.     }
  533.  
  534.     return TRUE;
  535. } /* ProcessToolTypes */
  536.  
  537.  
  538.